home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ddj0897.zip / DYN401.ZIP / threads / pipe.c < prev    next >
C/C++ Source or Header  |  1997-04-16  |  8KB  |  376 lines
  1.  
  2.  
  3. /*  Copyright (c) 1993-1996 Algorithms Corporation  */
  4. /*  All rights reserved.  */
  5.  
  6.  
  7.  
  8.  
  9. /*  This file automatically generated by dpp - do not edit  */
  10.  
  11. #define    DPP_STRATEGY    2
  12. #define    DPP_FASTWIDE    0
  13.  
  14.  
  15.  
  16. #line 18 "pipe.d"
  17. #include <string.h> 
  18.  
  19. #define    CLASS    Pipe_c
  20. #define    ivType    Pipe_iv_t
  21.  
  22. #include "generics.h"
  23.  
  24. object    Pipe_c;
  25.  
  26.  
  27. #line 28 "pipe.c"
  28. typedef struct  _Pipe_iv_t  {
  29.     object iObj;
  30.     char * iName;
  31.     char * iBuf;
  32.     int iBufsiz;
  33.     char * iWptr;
  34.     char * iRptr;
  35.     object iRblk;
  36.     object iWblk;
  37.     int iRblock;
  38.     int iWblock;
  39.     struct _Pipe_iv_t * iNext;
  40. }    Pipe_iv_t;
  41.  
  42.  
  43. #line 44 "pipe.c"
  44. typedef struct  _Pipe_cv_t  {
  45.     struct _Pipe_iv_t * cMpl;
  46. }    Pipe_cv_t;
  47.  
  48. static    Pipe_cv_t    *Pipe_cv;
  49.  
  50.  
  51.  
  52. #line 38 "pipe.d"
  53. cmeth objrtn New(object self, char *name, int bufsiz)
  54. { 
  55.     object obj = oSuper(Pipe_c, gNew, self)(self); 
  56.     ivType *iv = ivPtr(obj); 
  57.  
  58.     iv->iObj = obj; 
  59.     if (name) { 
  60.         iv->iName = Tnalloc(char, strlen(name)+1); 
  61.         strcpy(iv->iName, name); 
  62.     } 
  63.     iv->iBuf = Tnalloc(char, bufsiz); 
  64.     iv->iBufsiz = bufsiz; 
  65.     iv->iWptr = iv->iRptr = iv->iBuf; 
  66.     iv->iNext = Pipe_cv->cMpl; 
  67.     Pipe_cv->cMpl = iv; 
  68.     return obj; 
  69. } 
  70.  
  71. cmeth objrtn Pipe_cm_gNew(object self)
  72. { 
  73.     return New(self, NULL, 128); 
  74. } 
  75.  
  76. imeth int Pipe_im_gWrite(object self, char *buf, unsigned sz)
  77. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  78.     int room, rroom, bytes, w=0; 
  79.  
  80.     if (iv->iWblk) 
  81.         return 0; 
  82.     while (sz) { 
  83.  
  84.  
  85.         room = iv->iBufsiz - (iv->iWptr - iv->iBuf); 
  86.  
  87.  
  88.  
  89.         if (room < (int) sz) { 
  90.             rroom = iv->iRptr - iv->iBuf; 
  91.             if (rroom) { 
  92.                 bytes = iv->iWptr - iv->iRptr; 
  93.                 memmove(iv->iBuf, iv->iRptr, bytes); 
  94.                 iv->iRptr = iv->iBuf; 
  95.                 iv->iWptr = iv->iBuf + bytes; 
  96.                 room = iv->iBufsiz - (iv->iWptr - iv->iBuf); 
  97.             } 
  98.         } 
  99.  
  100.         bytes = (int) sz > room ? room : (int) sz; 
  101.         if (bytes) { 
  102.             memcpy(iv->iWptr, buf, bytes); 
  103.             iv->iWptr += bytes; 
  104.             buf += bytes; 
  105.             sz -= bytes; 
  106.             w += bytes; 
  107.             if (iv->iRblk) 
  108.                 gRelease(iv->iRblk, 0); 
  109.         } 
  110.  
  111.  
  112.         room = iv->iBufsiz - (iv->iWptr - iv->iRptr); 
  113.         if (sz && !room && iv->iWblock) { 
  114.             iv->iWblk = gFindStr(Thread, NULL); 
  115.             gHold(iv->iWblk); 
  116.             iv->iWblk = NULL; 
  117.         } 
  118.         if (!iv->iWblock) 
  119.             break; 
  120.     } 
  121.     return(w); 
  122. } 
  123.  
  124. imeth int Pipe_im_gRead(object self, char *buf, unsigned sz)
  125. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  126.     int ba; 
  127.     int bg; 
  128.     int tr=0; 
  129.  
  130.     if (iv->iRblk) 
  131.         return 0; 
  132.     while (sz) { 
  133.         ba = iv->iWptr - iv->iRptr; 
  134.         bg = ba < (int) sz ? ba : (int) sz; 
  135.         if (bg) { 
  136.             memcpy(buf, iv->iRptr, bg); 
  137.             buf += bg; 
  138.             iv->iRptr += bg; 
  139.             sz -= bg; 
  140.             tr += bg; 
  141.             if (iv->iWblk) 
  142.                 gRelease(iv->iWblk, 0); 
  143.         } 
  144.  
  145.         ba = iv->iWptr - iv->iRptr; 
  146.         if (sz && !ba && iv->iRblock) { 
  147.             iv->iRblk = gFindStr(Thread, NULL); 
  148.             gHold(iv->iRblk); 
  149.             iv->iRblk = NULL; 
  150.         } 
  151.         if (!iv->iRblock) 
  152.             break; 
  153.     } 
  154.     return(tr); 
  155. } 
  156.  
  157. imeth char * Pipe_im_gGets(object self, char *buf, int sz)
  158. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  159.     int ba; 
  160.     int bg; 
  161.     int tr=0; 
  162.  
  163.     if (!(iv->iWptr - iv->iRptr) && !iv->iRblock || iv->iRblk || sz <= 0) 
  164.         return NULL; 
  165.     if (sz-- == 1) { 
  166.         *buf = '\0'; 
  167.         return buf; 
  168.     } 
  169.     while (sz) { 
  170.         ba = iv->iWptr - iv->iRptr; 
  171.         for (bg=0 ; bg < ba && bg < sz && iv->iRptr[bg++] != '\n' ; ); 
  172.         if (iv->iRptr[bg-1] == '\n') 
  173.             sz = bg; 
  174.         if (bg) { 
  175.             memcpy(buf, iv->iRptr, bg); 
  176.             buf += bg; 
  177.             iv->iRptr += bg; 
  178.             sz -= bg; 
  179.             tr += bg; 
  180.             if (iv->iWblk) 
  181.                 gRelease(iv->iWblk, 0); 
  182.         } 
  183.  
  184.         ba = iv->iWptr - iv->iRptr; 
  185.         if (sz && !ba && iv->iRblock) { 
  186.             iv->iRblk = gFindStr(Thread, NULL); 
  187.             gHold(iv->iRblk); 
  188.             iv->iRblk = NULL; 
  189.         } 
  190.         if (!iv->iRblock) 
  191.             break; 
  192.     } 
  193.     buf[tr] = '\0'; 
  194.     return buf; 
  195. } 
  196.  
  197. imeth objrtn Pipe_im_gDispose(object self)
  198. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  199.     ivType *t, *pt; 
  200.  
  201.     if (iv->iRblk || iv->iWblk) 
  202.         return NULL; 
  203.     for (t=Pipe_cv->cMpl, pt=NULL ; t ; pt=t, t=t->iNext) 
  204.         if (t == iv) { 
  205.         if (pt) 
  206.             pt->iNext = t->iNext; 
  207.         else 
  208.             Pipe_cv->cMpl = t->iNext; 
  209.         break; 
  210.     } 
  211.     if (iv->iName) { 
  212.         free(iv->iName); 
  213.         iv->iName = NULL; 
  214.     } 
  215.     if (iv->iBuf) { 
  216.         free(iv->iBuf); 
  217.         iv->iBuf = NULL; 
  218.     } 
  219.     return oSuper(Pipe_c, gDispose, self)(self); 
  220. } 
  221.  
  222. cmeth objrtn Pipe_cm_gFindStr(object self, char *name)
  223. { 
  224.     ivType *p; 
  225.  
  226.     USE(self); 
  227.     if (!name) 
  228.         return NULL; 
  229.     for (p=Pipe_cv->cMpl ; p ; p=p->iNext) 
  230.         if (p->iName && !strcmp(p->iName, name)) 
  231.         return p->iObj; 
  232.     return NULL; 
  233. } 
  234.  
  235. imeth long Pipe_im_gLength(object self)
  236. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  237. #if 0 
  238.         if (iv->iRblock && !(iv->iWptr - iv->iRptr)) { 
  239.         iv->iRblk = gFindStr(Thread, NULL); 
  240.         gHold(iv->iRblk); 
  241.         iv->iRblk = NULL; 
  242.     } 
  243. #endif 
  244.         return iv->iWptr - iv->iRptr; 
  245. } 
  246.  
  247. imeth int Pipe_im_gRoom(object self)
  248. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  249. #if 0 
  250.         if (iv->iWblock && !(iv->iBufsiz - (iv->iWptr - iv->iRptr))) { 
  251.         iv->iWblk = gFindStr(Thread, NULL); 
  252.         gHold(iv->iWblk); 
  253.         iv->iWblk = NULL; 
  254.     } 
  255. #endif 
  256.         return iv->iBufsiz - (iv->iWptr - iv->iRptr); 
  257. } 
  258.  
  259. imeth int Pipe_im_gSize(object self)
  260. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  261.     return iv->iBufsiz; 
  262. } 
  263.  
  264. imeth char * Pipe_im_gName(object self)
  265. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  266.     return iv->iName; 
  267. } 
  268.  
  269. imeth objrtn Pipe_im_gMode(object self, int rblock, int wblock)
  270. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  271.     iv->iRblock = rblock; 
  272.     iv->iWblock = wblock; 
  273.     return self; 
  274. } 
  275.  
  276. imeth long Pipe_im_gAdvance(object self, long sz)
  277. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  278.     int ba; 
  279.     int bg; 
  280.     long tr=0; 
  281.  
  282.     if (iv->iRblk) 
  283.         return 0; 
  284.     while (sz) { 
  285.         ba = iv->iWptr - iv->iRptr; 
  286.         bg = (long) ba < sz ? ba : (int) sz; 
  287.         if (bg) { 
  288.             iv->iRptr += bg; 
  289.             sz -= bg; 
  290.             tr += bg; 
  291.             if (iv->iWblk) 
  292.                 gRelease(iv->iWblk, 0); 
  293.         } 
  294.  
  295.         ba = iv->iWptr - iv->iRptr; 
  296.         if (sz && !ba && iv->iRblock) { 
  297.             iv->iRblk = gFindStr(Thread, NULL); 
  298.             gHold(iv->iRblk); 
  299.             iv->iRblk = NULL; 
  300.         } 
  301.         if (!iv->iRblock) 
  302.             break; 
  303.     } 
  304.     return(tr); 
  305. } 
  306.  
  307. imeth long Pipe_im_gPosition(object self)
  308. { 
  309.     USE(self); 
  310.     return 0L; 
  311. } 
  312.  
  313. imeth int Pipe_im_gEndOfStream(object self)
  314. { Pipe_iv_t *iv = GetIVs(Pipe, self);
  315.     return !(iv->iWptr - iv->iRptr); 
  316. } 
  317.  
  318.  
  319. #line 320 "pipe.c"
  320.  
  321. objrtn    Pipe_initialize(void)
  322. {
  323.     static  CRITICALSECTION  cs;
  324.     static  int volatile once = 0;
  325.  
  326.     ENTERCRITICALSECTION(_CI_CS_);
  327.     if (!once) {
  328.         INITIALIZECRITICALSECTION(cs);
  329.         once = 1;
  330.     }
  331.     LEAVECRITICALSECTION(_CI_CS_);
  332.  
  333.     ENTERCRITICALSECTION(cs);
  334.  
  335.     if (Pipe_c) {
  336.         LEAVECRITICALSECTION(cs);
  337.         return Pipe_c;
  338.     }
  339.     INHIBIT_THREADER;
  340.     Stream_initialize();
  341.     if (Pipe_c)  {
  342.         ENABLE_THREADER;
  343.         LEAVECRITICALSECTION(cs);
  344.         return Pipe_c;
  345.     }
  346.     Pipe_c = gNewClass(Class, "Pipe", sizeof(Pipe_iv_t), sizeof(Pipe_cv_t), Stream, END);
  347.     cMethodFor(Pipe, gNewWithStrInt, New);
  348.     cMethodFor(Pipe, gFindStr, Pipe_cm_gFindStr);
  349.     cMethodFor(Pipe, gNew, Pipe_cm_gNew);
  350.     iMethodFor(Pipe, gPosition, Pipe_im_gPosition);
  351.     iMethodFor(Pipe, gLength, Pipe_im_gLength);
  352.     iMethodFor(Pipe, gWrite, Pipe_im_gWrite);
  353.     iMethodFor(Pipe, gEndOfStream, Pipe_im_gEndOfStream);
  354.     iMethodFor(Pipe, gAdvance, Pipe_im_gAdvance);
  355.     iMethodFor(Pipe, gSize, Pipe_im_gSize);
  356.     iMethodFor(Pipe, gDispose, Pipe_im_gDispose);
  357.     iMethodFor(Pipe, gName, Pipe_im_gName);
  358.     iMethodFor(Pipe, gGets, Pipe_im_gGets);
  359.     iMethodFor(Pipe, gGCDispose, Pipe_im_gDispose);
  360.     iMethodFor(Pipe, gDeepDispose, Pipe_im_gDispose);
  361.     iMethodFor(Pipe, gRead, Pipe_im_gRead);
  362.     iMethodFor(Pipe, gRoom, Pipe_im_gRoom);
  363.     iMethodFor(Pipe, gMode, Pipe_im_gMode);
  364.  
  365.     Pipe_cv = GetCVs(Pipe);
  366.  
  367.     ENABLE_THREADER;
  368.  
  369.     LEAVECRITICALSECTION(cs);
  370.  
  371.     return Pipe_c;
  372. }
  373.  
  374.  
  375.  
  376.